#Импорт библиотек
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.pipeline import make_pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, MinMaxScaler, OrdinalEncoder,StandardScaler
from sklearn.ensemble import RandomForestRegressor
from sklearn import metrics
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.linear_model import Lasso
from sklearn.neighbors import KNeighborsRegressor
from sklearn.dummy import DummyRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.svm import SVR
from sklearn.model_selection import GridSearchCV
from sklearn.neural_network import MLPRegressor
from sklearn.multioutput import MultiOutputRegressor
warnings.filterwarnings("ignore")

import tensorflow as tf
from tensorflow import keras
from keras import models
from keras import layers
from keras.layers import Activation, Dense, Dropout
from keras.layers import BatchNormalization
from tensorflow.keras.optimizers import SGD
from keras.models import Sequential

pip install --upgrade scikit-learn

Requirement already satisfied: scikit-learn in c:\users\mariia\anaconda3\lib\site-packages (1.7.0)
Requirement already satisfied: numpy>=1.22.0 in c:\users\mariia\anaconda3\lib\site-packages (from scikit-learn) (1.26.4)
Requirement already satisfied: scipy>=1.8.0 in c:\users\mariia\anaconda3\lib\site-packages (from scikit-learn) (1.13.1)
Requirement already satisfied: joblib>=1.2.0 in c:\users\mariia\anaconda3\lib\site-packages (from scikit-learn) (1.4.2)
Requirement already satisfied: threadpoolctl>=3.1.0 in c:\users\mariia\anaconda3\lib\site-packages (from scikit-learn) (3.5.0)
Note: you may need to restart the kernel to use updated packages.

#Загружаем первый dataset
df_xbp=pd.read_excel(r"C:\Users\Mariia\Documents\Аналитик данных БАУМАНСКИЙ\АТТЕСТАЦИОННОЕ ЗАДАНИЕ\Датасет для ВКР_композиты\X_bp.xlsx")
df_xbp.head()

#Выведем информацию о первом datasete. Размерность 1023 строк, 11 колонок. Пропусков нет.
df_xbp.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1023 entries, 0 to 1022
Data columns (total 11 columns):
 #   Column                                Non-Null Count  Dtype  
---  ------                                --------------  -----  
 0   Unnamed: 0                            1023 non-null   int64  
 1   Соотношение матрица-наполнитель       1023 non-null   float64
 2   Плотность, кг/м3                      1023 non-null   float64
 3   модуль упругости, ГПа                 1023 non-null   float64
 4   Количество отвердителя, м.%           1023 non-null   float64
 5   Содержание эпоксидных групп,%_2       1023 non-null   float64
 6   Температура вспышки, С_2              1023 non-null   float64
 7   Поверхностная плотность, г/м2         1023 non-null   float64
 8   Модуль упругости при растяжении, ГПа  1023 non-null   float64
 9   Прочность при растяжении, МПа         1023 non-null   float64
 10  Потребление смолы, г/м2               1023 non-null   float64
dtypes: float64(10), int64(1)
memory usage: 88.0 KB

#Загружаем второй dataset
df_xnup=pd.read_excel(r"C:\Users\Mariia\Documents\Аналитик данных БАУМАНСКИЙ\АТТЕСТАЦИОННОЕ ЗАДАНИЕ\Датасет для ВКР_композиты\X_nup.xlsx")
df_xnup.head()

#Выводим информацию о втором datasete. Пропусков нет. Размерность 1040 строк, 4 колонки. Пропусков нет.
df_xnup.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1040 entries, 0 to 1039
Data columns (total 4 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   Unnamed: 0          1040 non-null   int64  
 1   Угол нашивки, град  1040 non-null   int64  
 2   Шаг нашивки         1040 non-null   float64
 3   Плотность нашивки   1040 non-null   float64
dtypes: float64(2), int64(2)
memory usage: 32.6 KB

#Удалим первый неинформативный столбец из первой выборки и выведем первые 5 строк на экран
df_xbp.drop(["Unnamed: 0"], axis=1, inplace=True)
df_xbp.head()

#Удалим первый неинформативный столбец из второй выборки и выведем первые 5 строк на экран
df_xnup.drop(["Unnamed: 0"], axis=1, inplace=True)
df_xnup.head()

#Выведем уникальные значения первого dataseta. Практически все значения уникальные.
df_xbp.nunique()

Соотношение матрица-наполнитель         1014
Плотность, кг/м3                        1013
модуль упругости, ГПа                   1020
Количество отвердителя, м.%             1005
Содержание эпоксидных групп,%_2         1004
Температура вспышки, С_2                1003
Поверхностная плотность, г/м2           1004
Модуль упругости при растяжении, ГПа    1004
Прочность при растяжении, МПа           1004
Потребление смолы, г/м2                 1003
dtype: int64

#Многие показатели имеют одинаковое количество уникальных значений, что подозрительно. Проверим на дублирующиеся данные.
dupl_rows=df_xbp[df_xbp.duplicated(['Содержание эпоксидных групп,%_2', 'Поверхностная плотность, г/м2', 'Модуль упругости при растяжении, ГПа', 'Прочность при растяжении, МПа'])]
print(dupl_rows)

    Соотношение матрица-наполнитель  Плотность, кг/м3  модуль упругости, ГПа  \
4                          2.771331            2030.0                  753.0   
5                          2.767918            2000.0                  748.0   
6                          2.569620            1910.0                  807.0   
10                         2.919678            2160.0                  933.0   
11                         2.877358            1990.0                 1628.0   
13                         2.919678            1980.0                  568.0   
14                         4.029126            1910.0                  800.0   
15                         2.934783            2030.0                  302.0   
16                         3.557018            1880.0                  313.0   
17                         4.193548            1950.0                  506.0   
18                         4.897959            1890.0                  540.0   
20                         2.877358            2000.0                  205.0   
22                         4.029126            1880.0                  622.0   

    Количество отвердителя, м.%  Содержание эпоксидных групп,%_2  \
4                        111.86                        22.267857   
5                        111.86                        22.267857   
6                        111.86                        22.267857   
10                       129.00                        21.250000   
11                       129.00                        21.250000   
13                       129.00                        21.250000   
14                       129.00                        21.250000   
15                       129.00                        21.250000   
16                       129.00                        21.250000   
17                       129.00                        21.250000   
18                       129.00                        21.250000   
20                       111.86                        22.267857   
22                       111.86                        22.267857   

    Температура вспышки, С_2  Поверхностная плотность, г/м2  \
4                 284.615385                          210.0   
5                 284.615385                          210.0   
6                 284.615385                          210.0   
10                300.000000                         1010.0   
11                300.000000                         1010.0   
13                300.000000                          470.0   
14                300.000000                          470.0   
15                300.000000                          210.0   
16                300.000000                          210.0   
17                300.000000                          380.0   
18                300.000000                          380.0   
20                284.615385                         1010.0   
22                284.615385                          470.0   

    Модуль упругости при растяжении, ГПа  Прочность при растяжении, МПа  \
4                              70.000000                    3000.000000   
5                              70.000000                    3000.000000   
6                              70.000000                    3000.000000   
10                             78.000000                    2000.000000   
11                             78.000000                    2000.000000   
13                             73.333333                    2455.555556   
14                             73.333333                    2455.555556   
15                             70.000000                    3000.000000   
16                             70.000000                    3000.000000   
17                             75.000000                    1800.000000   
18                             75.000000                    1800.000000   
20                             78.000000                    2000.000000   
22                             73.333333                    2455.555556   

    Потребление смолы, г/м2  
4                     220.0  
5                     220.0  
6                     220.0  
10                    300.0  
11                    300.0  
13                    220.0  
14                    220.0  
15                    220.0  
16                    220.0  
17                    120.0  
18                    120.0  
20                    300.0  
22                    220.0

#Выведем уникальные значения второго dataseta. Угол нашивки используем всего два показателя. Возможно преобразование в категориальные данные. 
df_xnup.nunique()

Угол нашивки, град       2
Шаг нашивки           1006
Плотность нашивки     1005
dtype: int64

#В обоих датасетах данные имеют численные значения (float64, integer64). Следовательно, преобразований в численный вид не требуется.

#Объединим datasets по типу INNER, что указано в задании
df_all=df_xbp.merge(df_xnup, left_index = True, right_index = True, how = 'inner')
df_all.head()

#Смотрим сколько строк и колонок в объединенном detasete
df_all.shape

(1023, 13)

#Выведем первые и последние стоки dataseta
df_all

#Выведем информацию о нем
df_all.info()

<class 'pandas.core.frame.DataFrame'>
Index: 1023 entries, 0 to 1022
Data columns (total 13 columns):
 #   Column                                Non-Null Count  Dtype  
---  ------                                --------------  -----  
 0   Соотношение матрица-наполнитель       1023 non-null   float64
 1   Плотность, кг/м3                      1023 non-null   float64
 2   модуль упругости, ГПа                 1023 non-null   float64
 3   Количество отвердителя, м.%           1023 non-null   float64
 4   Содержание эпоксидных групп,%_2       1023 non-null   float64
 5   Температура вспышки, С_2              1023 non-null   float64
 6   Поверхностная плотность, г/м2         1023 non-null   float64
 7   Модуль упругости при растяжении, ГПа  1023 non-null   float64
 8   Прочность при растяжении, МПа         1023 non-null   float64
 9   Потребление смолы, г/м2               1023 non-null   float64
 10  Угол нашивки, град                    1023 non-null   int64  
 11  Шаг нашивки                           1023 non-null   float64
 12  Плотность нашивки                     1023 non-null   float64
dtypes: float64(12), int64(1)
memory usage: 111.9 KB

#Поиск уникальных значений
df_all.nunique()

Соотношение матрица-наполнитель         1014
Плотность, кг/м3                        1013
модуль упругости, ГПа                   1020
Количество отвердителя, м.%             1005
Содержание эпоксидных групп,%_2         1004
Температура вспышки, С_2                1003
Поверхностная плотность, г/м2           1004
Модуль упругости при растяжении, ГПа    1004
Прочность при растяжении, МПа           1004
Потребление смолы, г/м2                 1003
Угол нашивки, град                         2
Шаг нашивки                              989
Плотность нашивки                        988
dtype: int64

#Выведем данные описательной статистики при помощи функции describe
df_all.describe()

# Строим графики: распределения переменных и "ящики с усами"
fig, axes = plt.subplots(13, 2, figsize=(10, 45))
for k, column in enumerate(df_all.columns):    
    sns.histplot(data=df_all, x=column, kde=True, ax=axes[k, 0], color='r')
    sns.boxplot(data=df_all, x=column, ax=axes[k, 1], color='g')
plt.show()

# Построим графики рассеяния
sns.pairplot(df_all)

<seaborn.axisgrid.PairGrid at 0x22b93435760>

#Строим попарную корреляцию между столбцами
df_all.corr()

# Построим матрицу корреляции 
corr = df_all.corr()
fig, ax = plt.subplots(figsize=(10, 7))
sns.heatmap(corr, vmin=-1, vmax=1, annot=True, fmt='.2f', cmap='BrBG')
plt.show()

#Видим, что корреляция между переменными слабая

# Видим, что показатели распределены нормально, поэтому можно применить и стандартизацию и нормализацию данных
# Имеем выбросы, определяем их количество и думаем нужно ли их удалить или заменить на Nan

#Вводим переменные
count_3s = 0
count_iq = 0
for column in df_all:
    d = df_all.loc[:, [column]]
    
    # методом 3-х сигм
    zscore = (df_all[column] - df_all[column].mean()) / df_all[column].std()
    d['3s'] = zscore.abs() > 3
    count_3s += d['3s'].sum()
    
    # методом межквартильных расстояний
    q1 = np.quantile(df_all[column], .25)
    q3 = np.quantile(df_all[column], .75)
    iqr = q3 - q1
    lower = q1 - 1.5 * iqr
    upper = q3 + 1.5 * iqr
    d['iq'] = (df_all[column] < lower) | (df_all[column] > upper)
    count_iq += d['iq'].sum()
    
    # визуализируем выбросы
    print('{}: 3s={} iq={}'.format(column, d['3s'].sum(), d['iq'].sum()))
    fig, axes = plt.subplots(1, 2, figsize=(12, 2.5))
    sns.histplot(data=d, x=column, hue='3s', multiple='stack', legend=False, ax=axes[0])
    sns.boxplot(data=d, x=column, color='tab:green', ax=axes[1])
    sns.stripplot(data=d[d['iq']==False], x=column, ax=axes[1])
    sns.stripplot(data=d[d['iq']==True], x=column, color='tab:red', ax=axes[1])
    plt.show()
 
print('Метод 3-х сигм, выбросов:', count_3s)
print('Метод межквартильных расстояний, выбросов:', count_iq)

Соотношение матрица-наполнитель: 3s=0 iq=6

Плотность, кг/м3: 3s=3 iq=9

модуль упругости, ГПа: 3s=2 iq=2

Количество отвердителя, м.%: 3s=2 iq=14

Содержание эпоксидных групп,%_2: 3s=2 iq=2

Температура вспышки, С_2: 3s=3 iq=8

Поверхностная плотность, г/м2: 3s=2 iq=2

Модуль упругости при растяжении, ГПа: 3s=0 iq=6

Прочность при растяжении, МПа: 3s=0 iq=11

Потребление смолы, г/м2: 3s=3 iq=8

#Данные распределены нормально. Поэтому можем удалить выбросы, обнаруженные методом трех сигм
outliers = pd.DataFrame(index=df_all.index)
for column in df_all:
    zscore = (df_all[column] - df_all[column].mean()) / df_all[column].std()
    outliers[column] = (zscore.abs() > 3)
df_all = df_all[outliers.sum(axis=1)==0]
df_all.shape

(1000, 13)

df_all.columns

Index(['Соотношение матрица-наполнитель', 'Плотность, кг/м3',
       'модуль упругости, ГПа', 'Количество отвердителя, м.%',
       'Содержание эпоксидных групп,%_2', 'Температура вспышки, С_2',
       'Поверхностная плотность, г/м2', 'Модуль упругости при растяжении, ГПа',
       'Прочность при растяжении, МПа', 'Потребление смолы, г/м2',
       'Угол нашивки, град', 'Шаг нашивки', 'Плотность нашивки'],
      dtype='object')

# Разбиваем датасет на входные данные X и таргет Y
# Создаем переменную Y и убираем ее из датасета, так как будем предсказывать
y1 = df_all['Модуль упругости при растяжении, ГПа'].copy()
y2 = df_all['Прочность при растяжении, МПа'].copy()
df_old = df_all.copy()
df_all.drop(['Модуль упругости при растяжении, ГПа', 'Прочность при растяжении, МПа'], axis=1, inplace=True)
X=df_all.copy()

y1.describe()

count    1000.000000
mean       73.318178
std         3.113817
min        64.054061
25%        71.248823
50%        73.230375
75%        75.326573
max        82.682051
Name: Модуль упругости при растяжении, ГПа, dtype: float64

y2.describe()

count    1000.000000
mean     2464.864198
std       485.015353
min      1036.856605
25%      2134.535871
50%      2456.394188
75%      2760.163022
max      3848.436732
Name: Прочность при растяжении, МПа, dtype: float64

df_all.head()

##Нормализация данных
min_max_scaler = MinMaxScaler()
ds_norm=min_max_scaler.fit_transform(np.array(X))
ds_norm[:1]

array([[0.28213084, 0.60138107, 0.44706097, 0.12304725, 0.60743528,
        0.48282339, 0.16223008, 0.51741812, 0.        , 0.27510888,
        0.54465195]])

df_norm=pd.DataFrame(data=ds_norm, columns=['Соотношение матрица-наполнитель', 'Плотность, кг/м3',
       'модуль упругости, ГПа', 'Количество отвердителя, м.%',
       'Содержание эпоксидных групп,%_2', 'Температура вспышки, С_2',
       'Поверхностная плотность, г/м2', 'Потребление смолы, г/м2',
       'Угол нашивки, град', 'Шаг нашивки', 'Плотность нашивки'])
df_norm.head()

df_norm.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000 entries, 0 to 999
Data columns (total 11 columns):
 #   Column                           Non-Null Count  Dtype  
---  ------                           --------------  -----  
 0   Соотношение матрица-наполнитель  1000 non-null   float64
 1   Плотность, кг/м3                 1000 non-null   float64
 2   модуль упругости, ГПа            1000 non-null   float64
 3   Количество отвердителя, м.%      1000 non-null   float64
 4   Содержание эпоксидных групп,%_2  1000 non-null   float64
 5   Температура вспышки, С_2         1000 non-null   float64
 6   Поверхностная плотность, г/м2    1000 non-null   float64
 7   Потребление смолы, г/м2          1000 non-null   float64
 8   Угол нашивки, град               1000 non-null   float64
 9   Шаг нашивки                      1000 non-null   float64
 10  Плотность нашивки                1000 non-null   float64
dtypes: float64(11)
memory usage: 86.1 KB

# Категориальные данные при нормализации преобразовались в 0 и 1 и можно не применять OneHotEncoding
df_norm['Угол нашивки, град'].unique ()

array([0., 1.])

X_norm=df_norm
X_norm.head()

# Разбиваем датасет на train и test выборки
# в тестовую часть уходит 30%, в трейновую все остальное
X1_train_full, X1_test_full, y1_train, y1_test = train_test_split(X_norm, y1, 
                                                                train_size=0.7, test_size=0.3,
                                                                random_state=0)
X2_train_full, X2_test_full, y2_train, y2_test = train_test_split(X_norm, y2, 
                                                                train_size=0.7, test_size=0.3,
                                                                random_state=0)

x1_tr_f = X1_train_full

# Проверка правильности разбивки
df_norm.shape[0] - X1_train_full.shape[0] - X1_test_full.shape[0]

0

# Проверка правильности разбивки
df_norm.shape[0] - X2_train_full.shape[0] - X2_test_full.shape[0]

0

# Смотрим не удалили ли лишнего
print(len(X_norm.columns), len(X1_train_full.columns))
X1_train_full.shape, X2_train_full.shape

11 11

((700, 11), (700, 11))

X1_train_full.head()

y1_train.head()

110    76.179383
72     75.321098
494    71.444581
410    71.169400
447    73.528438
Name: Модуль упругости при растяжении, ГПа, dtype: float64

y1_train.shape

(700,)

# Функция для сравнения результатов предсказаний с моделью, выдающей среднее значение по тестовой выборке
def mean_model(y1_test):
    return [np.mean(y1_test) for _ in range(len(y1_test))]
y1_pred_mean = mean_model(y1_test)

##Рассмотрим Модуль упругости при растяжении, ГПа

'''#Построение модели методом Случайного леса и вузуализация модели
rfr1 = RandomForestRegressor(n_estimators = 15,max_depth = 7, random_state = 33)
rfr1.fit(X1_train_full, y1_train.values)
y1_pred_forest = rfr1.predict(X1_test_full)
mae_rfr1 = metrics.mean_absolute_error(y1_pred_forest, y1_test)
mse_rfr_elast1 = metrics.mean_squared_error(y1_test,y1_pred_forest)
print('Random Forest Regressor Results Train:')
print("Train score: {:.2f}".format(rfr1.score(X1_train_full, y1_train))) # Производительность модели (score) для тренировочной выборки
print('Random Forest Regressor Results:')
print('RF_MAE: ', round(metrics.mean_absolute_error(y1_test, y1_pred_forest)))
print('RF_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y1_test, y1_pred_forest)))
print('RF_MSE: {:.2f}'.format(mse_rfr_elast1))
print("RF_RMSE: {:.2f}".format (np.sqrt(mse_rfr_elast1)))
print("Test score: {:.2f}".format(rfr1.score(X1_test_full, y1_test))) # Производительность модели для тестовой выборки'''

Random Forest Regressor Results Train:
Train score: 0.40
Random Forest Regressor Results:
RF_MAE:  3
RF_MAPE: 0.03
RF_MSE: 10.19
RF_RMSE: 3.19
Test score: -0.07

'''plt.figure(figsize=(7, 5))
plt.title("Тестовые и прогнозные значения Random Forest Regressor")
plt.plot(y1_pred_forest, label = "Прогноз", color = "red")
plt.plot(y1_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)'''

#Метод Линейной регресии
#построение модели и вузуализация
lr1 = LinearRegression()
lr1.fit(X1_train_full, y1_train)
y_pred_lr1 = lr1.predict(X1_test_full)
mae_lr1 = metrics.mean_absolute_error(y_pred_lr1, y1_test)
mse_lin_elast1 = metrics.mean_squared_error(y1_test, y_pred_lr1)
print('Linear Regression Results Train:') 
print("Train score: {:.2f}".format(lr1.score(X1_train_full, y1_train))) # Производительность модели score для тренировочной выборки
print('Linear Regression Results:')    
print('lr_MAE: ', round(metrics.mean_absolute_error(y1_test, y_pred_lr1)))
print('lr_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y1_test, y_pred_lr1)))
print('lr_MSE: {:.2f}'.format(mse_lin_elast1))
print("lr_RMSE: {:.2f}".format (np.sqrt(mse_lin_elast1)))
print("Test score: {:.2f}".format(lr1.score(X1_test_full, y1_test))) # Производительность модели для тестовой выборки

Linear Regression Results Train:
Train score: 0.02
Linear Regression Results:
lr_MAE:  3
lr_MAPE: 0.03
lr_MSE: 9.63
lr_RMSE: 3.10
Test score: -0.01

plt.figure(figsize = (7, 5))
plt.title("Тестовые и прогнозные значения Linear Regression")
plt.plot(y_pred_lr1, label = "Прогноз", color = 'red')
plt.plot(y1_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

#Метод опорных векторов SVR

svr1 = make_pipeline(StandardScaler(), SVR(kernel = 'rbf', C = 100.0, epsilon = 1.0))
#обучаем модель
svr1.fit(X1_train_full, np.ravel(y1_train))
#вычисляем коэффициент детерминации
y_pred_svr1 = svr1.predict(X1_test_full)
mae_svr1 = metrics.mean_absolute_error(y_pred_svr1, y1_test)
mse_svr_elast1 = metrics.mean_squared_error(y1_test,y_pred_svr1)
print('Support Vector Regression Results Train:') 
print("Train score: {:.2f}".format(svr1.score(X1_train_full, y1_train))) # Производительность модели для тренировочной выборки
print('Support Vector Regression Results:')
print('SVR_MAE:', round(metrics.mean_absolute_error(y1_test, y_pred_svr1)))
print('SVR_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y1_test, y_pred_svr1)))
print('SVR_MSE: {:.2f}'.format(mse_svr_elast1))
print("SVR_RMSE: {:.2f}".format (np.sqrt(mse_svr_elast1)))
print("Test score: {:.2f}".format(svr1.score(X1_test_full, y1_test))) # Производительность модели для тестовой выборки

Support Vector Regression Results Train:
Train score: 0.87
Support Vector Regression Results:
SVR_MAE: 3
SVR_MAPE: 0.04
SVR_MSE: 15.88
SVR_RMSE: 3.98
Test score: -0.66

#Результаты модели, выдающей среднее значение
mse_lin_elast1_mean = metrics.mean_squared_error(y1_test, y1_pred_mean)
print("MAE for mean target: ", mean_absolute_error(y1_test, y1_pred_mean))
print("MSE for mean target: ", mse_lin_elast1_mean)
print("RMSE for mean target: ", np.sqrt(mse_lin_elast1_mean))

MAE for mean target:  2.5022190225112437
MSE for mean target:  9.564375990932318
RMSE for mean target:  3.0926325340932954

plt.figure(figsize = (7, 5))
plt.title("Тестовые и прогнозные значения Support Vector Regression")
plt.plot(y_pred_svr1, label = "Прогноз", color = "red")
plt.plot(y1_test.values, label = "Тест", color = "blue")
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

# Метод К ближайших соседей - K Neighbors Regressor 
knn1 = KNeighborsRegressor(n_neighbors=5)
knn1.fit(X1_train_full, y1_train)
y_pred_knn1 = knn1.predict(X1_test_full)
mae_knr1 = metrics.mean_absolute_error(y_pred_knn1, y1_test)
mse_knn_elast1 = metrics.mean_squared_error(y1_test,y_pred_knn1)
print('K Neighbors Regressor  Results Train:')
print("Train score: {:.2f}".format(knn1.score(X1_train_full, y1_train)))# Производительность модели Score для тренировочной выборки
print('K Neighbors Regressor  Results:')
print('KNN_MAE: ', round(metrics.mean_absolute_error(y1_test, y_pred_knn1)))
print('KNN_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y1_test, y_pred_knn1)))
print('KNN_MSE: {:.2f}'.format(mse_knn_elast1))
print("KNN_RMSE: {:.2f}".format (np.sqrt(mse_knn_elast1)))
print("Test score: {:.2f}".format(knn1.score(X1_test_full, y1_test)))# Производительность модели для тестовой выборки

K Neighbors Regressor  Results Train:
Train score: 0.24
K Neighbors Regressor  Results:
KNN_MAE:  3
KNN_MAPE: 0.04
KNN_MSE: 12.45
KNN_RMSE: 3.53
Test score: -0.30

plt.figure(figsize = (7, 5))
plt.title("Тестовые и прогнозные значения K Neighbors Regressor")
plt.plot(y_pred_knn1, label = "Прогноз", color = 'red')
plt.plot(y1_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

#Метод Градиентного бустинга (Gradient Boosting Regressor)
gbr1 = make_pipeline(StandardScaler(), GradientBoostingRegressor())
gbr1.fit(X1_train_full, np.ravel(y1_train))
y_pred_gbr1 = gbr1.predict(X1_test_full)
mae_gbr1 = metrics.mean_absolute_error(y_pred_gbr1, y1_test)
mse_gbr_elast1 = metrics.mean_squared_error(y1_test,y_pred_gbr1)
print('Gradient Boosting Regressor Results Train:')
print("Train score: {:.2f}".format(gbr1.score(X1_train_full, y1_train))) # Производительность модели (score) для тренировочной выборки
print('Gradient Boosting Regressor Results:')
print('GBR_MAE: ', round(metrics.mean_absolute_error(y1_test, y_pred_gbr1)))
print('GBR_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y1_test, y_pred_gbr1)))
print('GBR_MSE: {:.2f}'.format(mse_gbr_elast1))
print("GBR_RMSE: {:.2f}".format (np.sqrt(mse_gbr_elast1)))
print("Test score: {:.2f}".format(gbr1.score(X1_test_full, y1_test)))# Score для тестовой выборки

Gradient Boosting Regressor Results Train:
Train score: 0.49
Gradient Boosting Regressor Results:
GBR_MAE:  3
GBR_MAPE: 0.04
GBR_MSE: 10.34
GBR_RMSE: 3.22
Test score: -0.08

plt.figure(figsize = (7, 5))
plt.title("Тестовые и прогнозные значения Gradient Boosting Regressor")
plt.plot(y_pred_gbr1, label = "Прогноз", color = "red")
plt.plot(y1_test.values, label = "Тест", color = "blue")
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

#Метод Decision Tree Regressor (Деревья решений)
dtr1 = DecisionTreeRegressor()
dtr1.fit(X1_train_full, y1_train.values)
y_pred_dtr1 = dtr1.predict(X1_test_full)
mae_dtr1 = metrics.mean_absolute_error(y_pred_dtr1, y1_test)
mse_dtr_elast1 = metrics.mean_squared_error(y1_test,y_pred_dtr1)
print('Decision Tree Regressor Results Train:')
print("Train score: {:.2f}".format(dtr1.score(X1_train_full, y1_train)))# Производительность модели (score) для тренировочной выборки
print('Decision Tree Regressor Results:')
print('DTR_MAE: ', round(metrics.mean_absolute_error(y1_test, y_pred_dtr1)))
print('DTR_MSE: {:.2f}'.format(mse_dtr_elast1))
print("DTR_RMSE: {:.2f}".format (np.sqrt(mse_dtr_elast1)))
print('DTR_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y1_test, y_pred_dtr1)))
print("Test score: {:.2f}".format(dtr1.score(X1_test_full, y1_test)))# Производительность модели (score) для тестовой выборки

Decision Tree Regressor Results Train:
Train score: 1.00
Decision Tree Regressor Results:
DTR_MAE:  4
DTR_MSE: 20.24
DTR_RMSE: 4.50
DTR_MAPE: 0.05
Test score: -1.12

plt.figure(figsize = (7, 5))
plt.title("Тестовые и прогнозные значения Decision Tree Regressor")
plt.plot(y_pred_dtr1, label = "Прогноз", color = 'red')
plt.plot(y1_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

#Построение модели методом Случайного леса и вузуализация модели
rfr1 = RandomForestRegressor(n_estimators = 15,max_depth = 7, random_state = 33)
rfr1.fit(X1_train_full, y1_train.values)
y1_pred_forest = rfr1.predict(X1_test_full)
mae_rfr1 = metrics.mean_absolute_error(y1_pred_forest, y1_test)
mse_rfr_elast1 = metrics.mean_squared_error(y1_test,y1_pred_forest)
print('Random Forest Regressor Results Train:')
print("Train score: {:.2f}".format(rfr1.score(X1_train_full, y1_train))) # Производительность модели (score) для тренировочной выборки
print('Random Forest Regressor Results:')
print('RF_MAE: ', round(metrics.mean_absolute_error(y1_test, y1_pred_forest)))
print('RF_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y1_test, y1_pred_forest)))
print('RF_MSE: {:.2f}'.format(mse_rfr_elast1))
print("RF_RMSE: {:.2f}".format (np.sqrt(mse_rfr_elast1)))
print("Test score: {:.2f}".format(rfr1.score(X1_test_full, y1_test))) # Производительность модели для тестовой выборки

Random Forest Regressor Results Train:
Train score: 0.40
Random Forest Regressor Results:
RF_MAE:  3
RF_MAPE: 0.03
RF_MSE: 10.19
RF_RMSE: 3.19
Test score: -0.07

plt.figure(figsize=(7, 5))
plt.title("Тестовые и прогнозные значения Random Forest Regressor")
plt.plot(y1_pred_forest, label = "Прогноз", color = "red")
plt.plot(y1_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

# Проведем поиск  по сетке гиперпараметров с перекрестной проверкой, количество блоков равно 10 (cv = 10), для модели случайного леса - Random Forest Regressor - 1
parametrs = { 'n_estimators': [200, 300],
              'max_depth': [9, 15],
              'max_features': ['sqrt'],
              'criterion': ['absolute_error'] }
grid21 = GridSearchCV(estimator = rfr1, param_grid  = parametrs, cv=10)
grid21.fit(X1_train_full, y1_train)

GridSearchCV(cv=10,
             estimator=RandomForestRegressor(max_depth=7, n_estimators=15,
                                             random_state=33),
             param_grid={'criterion': ['absolute_error'], 'max_depth': [9, 15],
                         'max_features': ['sqrt'], 'n_estimators': [200, 300]})

RandomForestRegressor(criterion='absolute_error', max_depth=9,
                      max_features='sqrt', n_estimators=200, random_state=33)

grid21.best_params_

{'criterion': 'absolute_error',
 'max_depth': 9,
 'max_features': 'sqrt',
 'n_estimators': 200}

#Выводим гиперпараметры для оптимальной модели
print(grid21.best_estimator_)
knr_u=grid21.best_estimator_
print(f'R2-score RFR для модуля упрогости при растяжении: {knr_u.score(X1_test_full,y1_test)}')

RandomForestRegressor(criterion='absolute_error', max_depth=9,
                      max_features='sqrt', n_estimators=200, random_state=33)
R2-score RFR для модуля упрогости при растяжении: -0.016317015602618445

# подставим оптимальные гиперпараметры в нашу модель случайного леса
rfr21_grid = RandomForestRegressor(n_estimators=200, criterion='absolute_error', max_depth=9, max_features='sqrt')
#Обучаем модель
rfr21_grid.fit(X1_train_full, y1_train)

predictions_rfr21_grid = rfr21_grid.predict(X1_test_full)
#Оцениваем точность на тестовом наборе
mae_rfr21_grid = mean_absolute_error(predictions_rfr21_grid, y1_test)
mae_rfr21_grid

2.523202933050192

#сравним наши модели по метрике МАЕ, которая измеряет среднее абсолютное отклонение между предсказанными и фактическими значениями
mae_df1 = {'Регрессор': [ 'RandomForest', 'Linear Regression', 'KNeighbors','Support Vector','GradientBoosting',  'DecisionTree', ], 'MAE': [ mae_rfr1, mae_lr1, mae_knr1, mae_svr1, mae_gbr1, mae_dtr1 ]} 
mae_df1 = pd.DataFrame(mae_df1)

mae_df1

mae_df1.loc[ len(mae_df1.index )] = ['RandomForest1_GridSearchCV', mae_rfr21_grid]

# Проведем поиск  по сетке гиперпараметров с перекрестной проверкой, количество блоков равно 10 (cv = 10), для 
# Метода К ближайших соседей - K Neighbors Regressor - 5
knn21 = KNeighborsRegressor()
knn21_params = {'n_neighbors' : range(1, 301, 2), 
          'weights' : ['uniform', 'distance'],
          'algorithm' : ['auto', 'ball_tree', 'kd_tree', 'brute']
          }
#Запустим обучение модели. В качестве оценки модели будем использовать коэффициент детерминации (R^2)
# Если R2<0, это значит, что разработанная модель даёт прогноз даже хуже, чем простое усреднение.
gs21 = GridSearchCV(knn21, knn21_params, cv = 10, verbose = 1, n_jobs=-1, scoring = 'r2')
gs21.fit(X1_train_full, y1_train)
knn_21 = gs21.best_estimator_
gs21.best_params_

Fitting 10 folds for each of 1200 candidates, totalling 12000 fits

{'algorithm': 'auto', 'n_neighbors': 193, 'weights': 'uniform'}

#Выводим гиперпараметры для оптимальной модели
print(gs21.best_estimator_)
gs121 = gs21.best_estimator_
print(f'R2-score KNR для модуля упругости при растяжении: {gs121.score(X1_test_full, y1_test)}')

KNeighborsRegressor(n_neighbors=193)
R2-score KNR для модуля упругости при растяжении: -0.01840750260397095

#подставим оптимальные гиперпараметры в нашу модель метода к ближайших соседей
knn21_grid = KNeighborsRegressor(algorithm = 'auto', n_neighbors = 193, weights = 'uniform')
#Обучаем модель
knn21_grid.fit(X1_train_full, y1_train)
predictions_knn21_grid = knn21_grid.predict(X1_test_full)

#Оцениваем точность на тестовом наборе
mae_knn21_grid = mean_absolute_error(predictions_knn21_grid, y1_test)
mae_knn21_grid

2.5244972427257775

mae_df1.loc[ len(mae_df1.index )] = ['KNeighbors1_GridSearchCV', mae_knn21_grid]

# Проведем поиск  по сетке гиперпараметров с перекрестной проверкой, количество блоков равно 10 (cv = 10), для 
#Деревья решений - Decision Tree Regressor - 6
criterion21 = ['squared_error', 'friedman_mse', 'absolute_error', 'poisson']
splitter21 = ['best', 'random']
max_depth21 = [3,5,7,9,11]
min_samples_leaf21 = [100,150,200]
min_samples_split21 = [200,250,300]
max_features21 = ['auto', 'sqrt', 'log2']
param_grid21 = {'criterion': criterion21,
               'splitter': splitter21,
               'max_depth': max_depth21,
               'min_samples_split': min_samples_split21,
               'min_samples_leaf': min_samples_leaf21,
               'max_features': max_features21}
#Запустим обучение модели. В качестве оценки модели будем использовать коэффициент детерминации (R^2)
# Если R2<0, это значит, что разработанная модель даёт прогноз даже хуже, чем простое усреднение.
gs21 = GridSearchCV(dtr1, param_grid21, cv = 10, verbose = 1, n_jobs=-1, scoring = 'r2')
gs21.fit(X1_train_full, y1_train)
dtr_21 = gs21.best_estimator_
gs21.best_params_

Fitting 10 folds for each of 1080 candidates, totalling 10800 fits

{'criterion': 'absolute_error',
 'max_depth': 5,
 'max_features': 'log2',
 'min_samples_leaf': 150,
 'min_samples_split': 300,
 'splitter': 'best'}

#Выводим гиперпараметры для оптимальной модели
print(gs21.best_estimator_)
gs21 = gs21.best_estimator_
print(f'R2-score DTR для модуля упругости при растяжении: {gs21.score(X1_test_full, y1_test)}')

DecisionTreeRegressor(criterion='absolute_error', max_depth=5,
                      max_features='log2', min_samples_leaf=150,
                      min_samples_split=300)
R2-score DTR для модуля упругости при растяжении: -0.030637484086472044

#Подставим оптимальные гиперпараметры в нашу модель метода деревья решений
dtr21_grid = DecisionTreeRegressor(criterion='absolute_error', max_depth=5, max_features='log2',
                      min_samples_leaf=150, min_samples_split=300)
#Обучаем модель
dtr21_grid.fit(X1_train_full, y1_train)

predictions_dtr21_grid = dtr21_grid.predict(X1_test_full)
#Оцениваем точность на тестовом наборе
mae_dtr21_grid = mean_absolute_error(predictions_dtr21_grid, y1_test)
mae_dtr21_grid

2.54150595931716

mae_df1.loc[ len(mae_df1.index )] = ['DecisionTree1_GridSearchCV', mae_dtr21_grid]

mae_df1

###Прочность при растяжении

#Метод случайного леса (Random forest)
rfr2 = RandomForestRegressor(n_estimators = 15,max_depth = 7, random_state = 33)
rfr2.fit(X2_train_full, y2_train.values)
y2_pred_forest = rfr2.predict(X2_test_full)
mae_rfr2 = metrics.mean_absolute_error(y2_pred_forest, y2_test)
mse_rfr_elast2 = metrics.mean_squared_error(y2_test,y2_pred_forest)
print('Random Forest Regressor Results Train:')
print("Train score: {:.2f}".format(rfr1.score(X2_train_full, y2_train))) # Производительность модели для тренировочной выборки
print('Random Forest Regressor Results:')
print('RF_MAE: ', round(metrics.mean_absolute_error(y2_test, y2_pred_forest)))
print('RF_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y2_test, y2_pred_forest)))
print('RF_MSE: {:.2f}'.format(mse_rfr_elast2))
print("RF_RMSE: {:.2f}".format (np.sqrt(mse_rfr_elast2)))
print("Test score: {:.2f}".format(rfr2.score(X2_test_full, y2_test))) # Производительность модели для тестовой выборки

Random Forest Regressor Results Train:
Train score: -24.93
Random Forest Regressor Results:
RF_MAE:  401
RF_MAPE: 0.18
RF_MSE: 250450.54
RF_RMSE: 500.45
Test score: -0.02

plt.figure(figsize=(10, 7))
plt.title("Тестовые и прогнозные значения Random Forest Regressor")
plt.plot(y2_pred_forest, label = "Прогноз", color = "red")
plt.plot(y2_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

#Метод линейной регрессии
#Построение модели и вузуализация Линейной регрессии
lr2 = LinearRegression()
lr2.fit(X2_train_full, y2_train)
y_pred_lr2 = lr2.predict(X2_test_full)
mae_lr2 = metrics.mean_absolute_error(y_pred_lr2, y2_test)
mse_lin_elast2 = metrics.mean_squared_error(y2_test, y_pred_lr2)
print('Linear Regression Results Train:') # Производительность модели для тренировочной выборки
print("Ttain score: {:.2f}".format(lr2.score(X2_train_full, y2_train)))
print('Linear Regression Results:')    
print('lr_MAE: ', round(metrics.mean_absolute_error(y2_test, y_pred_lr2)))
print('lr_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y2_test, y_pred_lr2)))
print('lr_MSE: {:.2f}'.format(mse_lin_elast2))
print("lr_RMSE: {:.2f}".format (np.sqrt(mse_lin_elast2)))
print("Test score: {:.2f}".format(lr2.score(X2_test_full, y2_test))) # Производительность модели для тестовой выборки

Linear Regression Results Train:
Ttain score: 0.02
Linear Regression Results:
lr_MAE:  396
lr_MAPE: 0.18
lr_MSE: 240591.32
lr_RMSE: 490.50
Test score: 0.02

plt.figure(figsize = (10, 7))
plt.title("Тестовые и прогнозные значения Linear Regression")
plt.plot(y_pred_lr2, label = "Прогноз", color = 'red')
plt.plot(y2_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

# Метод К ближайших соседей - K Neighbors Regressor 
knn2 = KNeighborsRegressor(n_neighbors=5)
knn2.fit(X2_train_full, y2_train)
y_pred_knn2 = knn2.predict(X2_test_full)
mae_knr2 = metrics.mean_absolute_error(y_pred_knn2, y2_test)
mse_knn_elast2 = metrics.mean_squared_error(y2_test,y_pred_knn2)
print('K Neighbors Regressor  Results Train:')
print("Train score: {:.2f}".format(knn1.score(X2_train_full, y2_train)))# Производительность модели для тренировочной выборки
print('K Neighbors Regressor  Results:')
print('KNN_MAE: ', round(metrics.mean_absolute_error(y2_test, y_pred_knn2)))
print('KNN_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y2_test, y_pred_knn2)))
print('KNN_MSE: {:.2f}'.format(mse_knn_elast2))
print("KNN_RMSE: {:.2f}".format (np.sqrt(mse_knn_elast2)))
print("Test score: {:.2f}".format(knn1.score(X2_test_full, y2_test)))# Производительность модели для тестовой выборки

K Neighbors Regressor  Results Train:
Train score: -24.93
K Neighbors Regressor  Results:
KNN_MAE:  424
KNN_MAPE: 0.19
KNN_MSE: 284049.93
KNN_RMSE: 532.96
Test score: -23.08

plt.figure(figsize = (10, 7))
plt.title("Тестовые и прогнозные значения K Neighbors Regressor")
plt.plot(y_pred_knn2, label = "Прогноз", color = 'red')
plt.plot(y2_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

#Метод опорных векторов SVR
svr2 = make_pipeline(StandardScaler(), SVR(kernel = 'rbf', C = 500.0, epsilon = 1.0))
#обучаем модель
svr2.fit(X2_train_full, np.ravel(y2_train))
#вычисляем коэффициент детерминации
y_pred_svr2 = svr2.predict(X2_test_full)
mae_svr2 = metrics.mean_absolute_error(y_pred_svr2, y2_test)
mse_svr_elast2 = metrics.mean_squared_error(y2_test,y_pred_svr2)
print('Support Vector Regression Results Train:') 
print("Train score: {:.2f}".format(svr2.score(X2_train_full, y2_train))) # Производительность модели для тренировочной выборки
print('Support Vector Regression Results:')
print('SVR_MAE:', round(metrics.mean_absolute_error(y2_test, y_pred_svr2)))
print('SVR_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y2_test, y_pred_svr2)))
print('SVR_MSE: {:.2f}'.format(mse_svr_elast2))
print("SVR_RMSE: {:.2f}".format (np.sqrt(mse_svr_elast2)))
print("Test score: {:.2f}".format(svr2.score(X2_test_full, y2_test))) # Производительность модели для тестовой выборки

Support Vector Regression Results Train:
Train score: 0.30
Support Vector Regression Results:
SVR_MAE: 405
SVR_MAPE: 0.18
SVR_MSE: 257808.70
SVR_RMSE: 507.75
Test score: -0.05

plt.figure(figsize = (10, 7))
plt.title("Тестовые и прогнозные значения Support Vector Regression")
plt.plot(y_pred_svr2, label = "Прогноз", color = "red")
plt.plot(y2_test.values, label = "Тест", color = "blue")
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

#Метод градиентного спуска Gradient Boosting Regressor 
gbr2 = make_pipeline(StandardScaler(), GradientBoostingRegressor())
gbr2.fit(X2_train_full, np.ravel(y2_train))
y_pred_gbr2 = gbr2.predict(X2_test_full)
mae_gbr2 = metrics.mean_absolute_error(y_pred_gbr2, y2_test)
mse_gbr_elast2 = metrics.mean_squared_error(y2_test,y_pred_gbr2)
print('Gradient Boosting Regressor Results Train:')
print("Train score: {:.2f}".format(gbr2.score(X2_train_full, y2_train))) # Производительность модели для тренировочной выборки
print('Gradient Boosting Regressor Results:')
print('GBR_MAE: ', round(metrics.mean_absolute_error(y2_test, y_pred_gbr2)))
print('GBR_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y2_test, y_pred_gbr2)))
print('GBR_MSE: {:.2f}'.format(mse_gbr_elast2))
print("GBR_RMSE: {:.2f}".format (np.sqrt(mse_gbr_elast2)))
print("Test score: {:.2f}".format(gbr2.score(X2_test_full, y2_test)))# Производительность модели для тестовой выборки

Gradient Boosting Regressor Results Train:
Train score: 0.49
Gradient Boosting Regressor Results:
GBR_MAE:  411
GBR_MAPE: 0.18
GBR_MSE: 260453.55
GBR_RMSE: 510.35
Test score: -0.06

#Метод Деревьев решений
dtr2 = DecisionTreeRegressor()
dtr2.fit(X2_train_full, y2_train.values)
y_pred_dtr2 = dtr2.predict(X2_test_full)
mae_dtr2 = metrics.mean_absolute_error(y_pred_dtr2, y2_test)
mse_dtr_elast2 = metrics.mean_squared_error(y2_test,y_pred_dtr2)
print('Decision Tree Regressor Results Train:')
print("Train score: {:.2f}".format(dtr1.score(X2_train_full, y2_train)))# Производительность модели для тренировочной выборки
print('Decision Tree Regressor Results:')
print('DTR_MAE: ', round(metrics.mean_absolute_error(y2_test, y_pred_dtr2)))
print('DTR_MSE: {:.2f}'.format(mse_dtr_elast2))
print("DTR_RMSE: {:.2f}".format (np.sqrt(mse_dtr_elast2)))
print('DTR_MAPE: {:.2f}'.format(metrics.mean_absolute_percentage_error(y2_test, y_pred_dtr2)))
print("Test score: {:.2f}".format(dtr2.score(X2_test_full, y2_test)))# Производительность модели для тестовой выборки

Decision Tree Regressor Results Train:
Train score: -24.93
Decision Tree Regressor Results:
DTR_MAE:  565
DTR_MSE: 499793.93
DTR_RMSE: 706.96
DTR_MAPE: 0.25
Test score: -1.04

plt.figure(figsize = (10, 7))
plt.title("Тестовые и прогнозные значения Decision Tree Regressor")
plt.plot(y_pred_dtr2, label = "Прогноз", color = 'red')
plt.plot(y2_test.values, label = "Тест", color = 'blue')
plt.xlabel("Количество наблюдений")
plt.ylabel("Модуль упругости при растяжении, ГПа")
plt.legend()
plt.grid(True)

###Соотношение матрица-наполнитель

#Разбиваем данные на признаки х и таргет у
# создали переменную у и убрали из датасета ее, так как собираемся предстказывать
df_all=df_old
y3 = df_all['Соотношение матрица-наполнитель'].copy()
df_old=df_all.copy()
df_all.drop(['Соотношение матрица-наполнитель'], axis=1, inplace=True)
X3=df_all.copy()

X3.info()

<class 'pandas.core.frame.DataFrame'>
Index: 1000 entries, 1 to 1022
Data columns (total 12 columns):
 #   Column                                Non-Null Count  Dtype  
---  ------                                --------------  -----  
 0   Плотность, кг/м3                      1000 non-null   float64
 1   модуль упругости, ГПа                 1000 non-null   float64
 2   Количество отвердителя, м.%           1000 non-null   float64
 3   Содержание эпоксидных групп,%_2       1000 non-null   float64
 4   Температура вспышки, С_2              1000 non-null   float64
 5   Поверхностная плотность, г/м2         1000 non-null   float64
 6   Модуль упругости при растяжении, ГПа  1000 non-null   float64
 7   Прочность при растяжении, МПа         1000 non-null   float64
 8   Потребление смолы, г/м2               1000 non-null   float64
 9   Угол нашивки, град                    1000 non-null   int64  
 10  Шаг нашивки                           1000 non-null   float64
 11  Плотность нашивки                     1000 non-null   float64
dtypes: float64(11), int64(1)
memory usage: 101.6 KB

y3.describe()

count    1000.000000
mean        2.936299
std         0.908779
min         0.389403
25%         2.319283
50%         2.908811
75%         3.553931
max         5.591742
Name: Соотношение матрица-наполнитель, dtype: float64

#Нормализуем данные
min_max_scaler = MinMaxScaler()
ds_norm=min_max_scaler.fit_transform(np.array(X3))
ds_norm[:1]

array([[0.60138107, 0.44706097, 0.12304725, 0.60743528, 0.48282339,
        0.16223008, 0.31919382, 0.69823491, 0.51741812, 0.        ,
        0.27510888, 0.54465195]])

df_norm=pd.DataFrame(data=ds_norm, columns=['Плотность, кг/м3',
       'модуль упругости, ГПа', 'Количество отвердителя, м.%',
       'Содержание эпоксидных групп,%_2', 'Температура вспышки, С_2',
       'Поверхностная плотность, г/м2', 'Модуль упругости при растяжении, ГПа', 'Прочность при растяжении, МПа', 'Потребление смолы, г/м2',
       'Угол нашивки, град', 'Шаг нашивки', 'Плотность нашивки'])
df_norm.head()

df_norm.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000 entries, 0 to 999
Data columns (total 12 columns):
 #   Column                                Non-Null Count  Dtype  
---  ------                                --------------  -----  
 0   Плотность, кг/м3                      1000 non-null   float64
 1   модуль упругости, ГПа                 1000 non-null   float64
 2   Количество отвердителя, м.%           1000 non-null   float64
 3   Содержание эпоксидных групп,%_2       1000 non-null   float64
 4   Температура вспышки, С_2              1000 non-null   float64
 5   Поверхностная плотность, г/м2         1000 non-null   float64
 6   Модуль упругости при растяжении, ГПа  1000 non-null   float64
 7   Прочность при растяжении, МПа         1000 non-null   float64
 8   Потребление смолы, г/м2               1000 non-null   float64
 9   Угол нашивки, град                    1000 non-null   float64
 10  Шаг нашивки                           1000 non-null   float64
 11  Плотность нашивки                     1000 non-null   float64
dtypes: float64(12)
memory usage: 93.9 KB

df_norm['Угол нашивки, град'].unique ()

array([0., 1.])

X3_norm=df_norm
X3_norm.head()

# Разбиваем датасет на train/test 
X3_train_full, X3_test_full, y3_train, y3_test = train_test_split(X3_norm, y3, 
                                                                train_size=0.7, test_size=0.3,
                                                                random_state=0)

#  Промежуточная проверка размерности
print(len(X3_norm.columns), len(X3_train_full.columns))
X3_train_full.shape, X3_train_full.shape

12 12

((700, 12), (700, 12))

# Создаем НЕЙРОСЕТЬ
model6 = MLPRegressor(
    hidden_layer_sizes = 30,
    activation = 'relu',
    solver='adam',
    max_iter=4000,
    early_stopping = True,
    validation_fraction = 0.2,
    verbose=True
)

# Запускем нейросеть
model6.fit(X3_train_full, y3_train)

Iteration 1, loss = 4.90593529
Validation score: -10.625227
Iteration 2, loss = 4.70678735
Validation score: -10.159309
Iteration 3, loss = 4.51269028
Validation score: -9.707446
Iteration 4, loss = 4.32538587
Validation score: -9.266485
Iteration 5, loss = 4.14127322
Validation score: -8.834074
Iteration 6, loss = 3.96237954
Validation score: -8.408235
Iteration 7, loss = 3.78669403
Validation score: -7.989439
Iteration 8, loss = 3.61499909
Validation score: -7.577410
Iteration 9, loss = 3.44559895
Validation score: -7.170730
Iteration 10, loss = 3.27524073
Validation score: -6.768500
Iteration 11, loss = 3.11102661
Validation score: -6.370175
Iteration 12, loss = 2.94545782
Validation score: -5.978587
Iteration 13, loss = 2.78430205
Validation score: -5.589679
Iteration 14, loss = 2.62573975
Validation score: -5.204917
Iteration 15, loss = 2.46702695
Validation score: -4.825870
Iteration 16, loss = 2.31142169
Validation score: -4.452343
Iteration 17, loss = 2.15664154
Validation score: -4.085918
Iteration 18, loss = 2.00798140
Validation score: -3.725122
Iteration 19, loss = 1.86057948
Validation score: -3.371911
Iteration 20, loss = 1.71591024
Validation score: -3.026886
Iteration 21, loss = 1.57949444
Validation score: -2.691347
Iteration 22, loss = 1.44666885
Validation score: -2.370161
Iteration 23, loss = 1.31891885
Validation score: -2.067109
Iteration 24, loss = 1.19905085
Validation score: -1.784031
Iteration 25, loss = 1.08784208
Validation score: -1.521692
Iteration 26, loss = 0.98570808
Validation score: -1.281876
Iteration 27, loss = 0.89318171
Validation score: -1.065355
Iteration 28, loss = 0.81231761
Validation score: -0.872421
Iteration 29, loss = 0.73953364
Validation score: -0.704626
Iteration 30, loss = 0.67797127
Validation score: -0.560874
Iteration 31, loss = 0.62635713
Validation score: -0.439243
Iteration 32, loss = 0.58427093
Validation score: -0.338052
Iteration 33, loss = 0.55130226
Validation score: -0.255538
Iteration 34, loss = 0.52542834
Validation score: -0.189869
Iteration 35, loss = 0.50441720
Validation score: -0.138623
Iteration 36, loss = 0.48927191
Validation score: -0.098684
Iteration 37, loss = 0.47868305
Validation score: -0.068031
Iteration 38, loss = 0.47017259
Validation score: -0.045220
Iteration 39, loss = 0.46645462
Validation score: -0.028549
Iteration 40, loss = 0.46460728
Validation score: -0.018306
Iteration 41, loss = 0.46313746
Validation score: -0.012829
Iteration 42, loss = 0.46400855
Validation score: -0.009125
Iteration 43, loss = 0.46357090
Validation score: -0.007128
Iteration 44, loss = 0.46315295
Validation score: -0.005862
Iteration 45, loss = 0.46252884
Validation score: -0.005370
Iteration 46, loss = 0.46149587
Validation score: -0.005148
Iteration 47, loss = 0.46064704
Validation score: -0.005379
Iteration 48, loss = 0.45980918
Validation score: -0.006032
Iteration 49, loss = 0.45906143
Validation score: -0.006419
Iteration 50, loss = 0.45840812
Validation score: -0.006179
Iteration 51, loss = 0.45780799
Validation score: -0.005604
Iteration 52, loss = 0.45729188
Validation score: -0.004744
Iteration 53, loss = 0.45659122
Validation score: -0.003555
Iteration 54, loss = 0.45600205
Validation score: -0.001879
Iteration 55, loss = 0.45538602
Validation score: 0.000163
Iteration 56, loss = 0.45480103
Validation score: 0.001798
Iteration 57, loss = 0.45421850
Validation score: 0.003220
Iteration 58, loss = 0.45365154
Validation score: 0.004407
Iteration 59, loss = 0.45320316
Validation score: 0.005143
Iteration 60, loss = 0.45255038
Validation score: 0.005980
Iteration 61, loss = 0.45201808
Validation score: 0.007127
Iteration 62, loss = 0.45151308
Validation score: 0.007926
Iteration 63, loss = 0.45102559
Validation score: 0.008245
Iteration 64, loss = 0.45043563
Validation score: 0.009334
Iteration 65, loss = 0.44999167
Validation score: 0.010065
Iteration 66, loss = 0.44948603
Validation score: 0.011124
Iteration 67, loss = 0.44903189
Validation score: 0.012211
Iteration 68, loss = 0.44850482
Validation score: 0.013319
Iteration 69, loss = 0.44814701
Validation score: 0.014654
Iteration 70, loss = 0.44762821
Validation score: 0.015256
Iteration 71, loss = 0.44717294
Validation score: 0.015809
Iteration 72, loss = 0.44672051
Validation score: 0.016570
Iteration 73, loss = 0.44639879
Validation score: 0.016704
Iteration 74, loss = 0.44597072
Validation score: 0.017490
Iteration 75, loss = 0.44553690
Validation score: 0.018047
Iteration 76, loss = 0.44517160
Validation score: 0.019115
Iteration 77, loss = 0.44472034
Validation score: 0.019797
Iteration 78, loss = 0.44432778
Validation score: 0.020400
Iteration 79, loss = 0.44401133
Validation score: 0.021050
Iteration 80, loss = 0.44367177
Validation score: 0.021155
Iteration 81, loss = 0.44325072
Validation score: 0.021795
Iteration 82, loss = 0.44291951
Validation score: 0.022146
Iteration 83, loss = 0.44258445
Validation score: 0.022846
Iteration 84, loss = 0.44220968
Validation score: 0.023723
Iteration 85, loss = 0.44191386
Validation score: 0.024023
Iteration 86, loss = 0.44157766
Validation score: 0.024661
Iteration 87, loss = 0.44118552
Validation score: 0.025324
Iteration 88, loss = 0.44085629
Validation score: 0.026144
Iteration 89, loss = 0.44053825
Validation score: 0.026603
Iteration 90, loss = 0.44020831
Validation score: 0.027261
Iteration 91, loss = 0.43989216
Validation score: 0.027906
Iteration 92, loss = 0.43960840
Validation score: 0.028332
Iteration 93, loss = 0.43927727
Validation score: 0.028360
Iteration 94, loss = 0.43898447
Validation score: 0.028937
Iteration 95, loss = 0.43864708
Validation score: 0.029122
Iteration 96, loss = 0.43837857
Validation score: 0.029183
Iteration 97, loss = 0.43812783
Validation score: 0.029042
Iteration 98, loss = 0.43777555
Validation score: 0.029302
Iteration 99, loss = 0.43748671
Validation score: 0.029447
Iteration 100, loss = 0.43724025
Validation score: 0.030213
Iteration 101, loss = 0.43690355
Validation score: 0.030463
Iteration 102, loss = 0.43666640
Validation score: 0.031085
Iteration 103, loss = 0.43633453
Validation score: 0.031606
Iteration 104, loss = 0.43606088
Validation score: 0.031630
Iteration 105, loss = 0.43584273
Validation score: 0.032245
Iteration 106, loss = 0.43546264
Validation score: 0.032441
Iteration 107, loss = 0.43523786
Validation score: 0.032610
Iteration 108, loss = 0.43497558
Validation score: 0.032890
Iteration 109, loss = 0.43472717
Validation score: 0.032952
Iteration 110, loss = 0.43445905
Validation score: 0.032725
Iteration 111, loss = 0.43418136
Validation score: 0.032773
Iteration 112, loss = 0.43397236
Validation score: 0.032925
Iteration 113, loss = 0.43366597
Validation score: 0.033042
Iteration 114, loss = 0.43344087
Validation score: 0.033129
Iteration 115, loss = 0.43322099
Validation score: 0.033603
Iteration 116, loss = 0.43294869
Validation score: 0.033614
Iteration 117, loss = 0.43272618
Validation score: 0.034205
Iteration 118, loss = 0.43243261
Validation score: 0.034365
Iteration 119, loss = 0.43223462
Validation score: 0.034948
Iteration 120, loss = 0.43195920
Validation score: 0.035054
Iteration 121, loss = 0.43172269
Validation score: 0.035286
Iteration 122, loss = 0.43155764
Validation score: 0.035416
Iteration 123, loss = 0.43130573
Validation score: 0.035724
Iteration 124, loss = 0.43108785
Validation score: 0.035327
Iteration 125, loss = 0.43084762
Validation score: 0.035146
Iteration 126, loss = 0.43063825
Validation score: 0.035332
Iteration 127, loss = 0.43033904
Validation score: 0.035935
Iteration 128, loss = 0.43015185
Validation score: 0.036718
Iteration 129, loss = 0.42992938
Validation score: 0.037022
Iteration 130, loss = 0.42968402
Validation score: 0.037058
Iteration 131, loss = 0.42949564
Validation score: 0.036686
Iteration 132, loss = 0.42921940
Validation score: 0.036688
Iteration 133, loss = 0.42900552
Validation score: 0.036661
Iteration 134, loss = 0.42886962
Validation score: 0.037134
Iteration 135, loss = 0.42859788
Validation score: 0.037213
Iteration 136, loss = 0.42833178
Validation score: 0.036761
Iteration 137, loss = 0.42836007
Validation score: 0.036164
Iteration 138, loss = 0.42800203
Validation score: 0.036648
Iteration 139, loss = 0.42786692
Validation score: 0.037047
Iteration 140, loss = 0.42749097
Validation score: 0.036960
Validation score did not improve more than tol=0.000100 for 10 consecutive epochs. Stopping.

MLPRegressor(early_stopping=True, hidden_layer_sizes=30, max_iter=4000,
             validation_fraction=0.2, verbose=True)

# График ошибки
plt.plot(model6.loss_curve_)
plt.grid(True)
plt.show()

# Предсказание нейросети
y3_pred = model6.predict(X3_test_full)
prediction_df6 = pd.DataFrame({'Actual': y3_test, 'Predicted': y3_pred})
prediction_df6.head(3)

print('MAE3:', metrics.mean_absolute_error(y3_test, y3_pred))
print('MSE3:', metrics.mean_squared_error(y3_test, y3_pred))
print('RMSE3:', 
      np.sqrt(metrics.mean_squared_error(y3_test, y3_pred)))

MAE3: 0.7994235690741177
MSE3: 0.974118032555233
RMSE3: 0.9869741802880322

# Зададим функцию для визуализации факт/прогноз для результатов моделей
# Посмотрим на график результата работы модели
def actual_and_predicted_plot(orig, predict, var, model_name):
    plt.figure(figsize=(10,5))
    plt.title(f'Тестовые и прогнозные значения: {model_name}')
    plt.plot(orig, label = 'Тест')
    plt.plot(predict, label = 'Прогноз')
    plt.legend(loc = 'best')
    plt.ylabel(var)
    plt.xlabel('Количество наблюдений')
    plt.show()
actual_and_predicted_plot(y3_test.values, model6.predict(X3_test_full.values), 'Cоотношение матрица/наполнитель', 'Keras')

#Строим другую нейросеть, для рекомендации соотношения матрица-наполнитель
  
model_ns = tf.keras.Sequential()                

model_ns.add(Dense(16, input_dim=X3_train_full.shape[1], activation = 'relu'))
model_ns.add(BatchNormalization())
model_ns.add(Dense(8, activation = 'relu'))
model_ns.add(Dropout(0.18))
model_ns.add(Dense(8, activation = 'relu'))
model_ns.add(Dense(8, activation = 'relu'))
model_ns.add(Dense(1, activation = 'sigmoid'))


#компиляция
model_ns.compile(optimizer='adam', loss= 'mae', metrics=['mae'])
model_ns.summary()

#обучение модели
%time
history = model_ns.fit(X3_train_full, y3_train,
                    epochs=25,
                    batch_size = 32,
                    verbose=1,
                    validation_data=(X3_test_full, y3_test))

Model: "sequential_16"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ dense_64 (Dense)                     │ (None, 16)                  │             208 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_16               │ (None, 16)                  │              64 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_65 (Dense)                     │ (None, 8)                   │             136 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_11 (Dropout)                 │ (None, 8)                   │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_66 (Dense)                     │ (None, 8)                   │              72 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_67 (Dense)                     │ (None, 8)                   │              72 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_68 (Dense)                     │ (None, 1)                   │               9 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 561 (2.19 KB)

 Trainable params: 529 (2.07 KB)

 Non-trainable params: 32 (128.00 B)

CPU times: total: 0 ns
Wall time: 0 ns
Epoch 1/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 5s 36ms/step - loss: 2.3320 - mae: 2.3320 - val_loss: 2.4477 - val_mae: 2.4477
Epoch 2/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - loss: 2.3462 - mae: 2.3462 - val_loss: 2.4074 - val_mae: 2.4074
Epoch 3/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - loss: 2.3159 - mae: 2.3159 - val_loss: 2.3404 - val_mae: 2.3404
Epoch 4/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 13ms/step - loss: 2.2519 - mae: 2.2519 - val_loss: 2.2543 - val_mae: 2.2543
Epoch 5/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step - loss: 2.0784 - mae: 2.0784 - val_loss: 2.1622 - val_mae: 2.1622
Epoch 6/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - loss: 2.0885 - mae: 2.0885 - val_loss: 2.0856 - val_mae: 2.0856
Epoch 7/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - loss: 2.0581 - mae: 2.0581 - val_loss: 2.0446 - val_mae: 2.0446
Epoch 8/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - loss: 1.9444 - mae: 1.9444 - val_loss: 2.0236 - val_mae: 2.0236
Epoch 9/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - loss: 1.9322 - mae: 1.9322 - val_loss: 2.0116 - val_mae: 2.0116
Epoch 10/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - loss: 1.9712 - mae: 1.9712 - val_loss: 2.0028 - val_mae: 2.0028
Epoch 11/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step - loss: 1.9526 - mae: 1.9526 - val_loss: 1.9977 - val_mae: 1.9977
Epoch 12/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - loss: 1.9585 - mae: 1.9585 - val_loss: 1.9946 - val_mae: 1.9946
Epoch 13/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - loss: 1.9411 - mae: 1.9411 - val_loss: 1.9921 - val_mae: 1.9921
Epoch 14/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - loss: 1.9519 - mae: 1.9519 - val_loss: 1.9901 - val_mae: 1.9901
Epoch 15/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - loss: 1.8897 - mae: 1.8897 - val_loss: 1.9886 - val_mae: 1.9886
Epoch 16/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - loss: 1.9893 - mae: 1.9893 - val_loss: 1.9876 - val_mae: 1.9876
Epoch 17/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step - loss: 1.9646 - mae: 1.9646 - val_loss: 1.9872 - val_mae: 1.9872
Epoch 18/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - loss: 1.8968 - mae: 1.8968 - val_loss: 1.9867 - val_mae: 1.9867
Epoch 19/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - loss: 1.9134 - mae: 1.9134 - val_loss: 1.9864 - val_mae: 1.9864
Epoch 20/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step - loss: 1.9415 - mae: 1.9415 - val_loss: 1.9862 - val_mae: 1.9862
Epoch 21/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - loss: 1.9434 - mae: 1.9434 - val_loss: 1.9860 - val_mae: 1.9860
Epoch 22/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - loss: 1.9311 - mae: 1.9311 - val_loss: 1.9860 - val_mae: 1.9860
Epoch 23/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step - loss: 1.9168 - mae: 1.9168 - val_loss: 1.9859 - val_mae: 1.9859
Epoch 24/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - loss: 1.8908 - mae: 1.8908 - val_loss: 1.9858 - val_mae: 1.9858
Epoch 25/25
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - loss: 1.9310 - mae: 1.9310 - val_loss: 1.9858 - val_mae: 1.9858

#Визуализируем процесс обучения
plt.title('Обучение')
plt.xlabel('epochs')
plt.ylabel('MAE')
plt.plot(history.history['loss'], label= 'train')
plt.plot(history.history['val_loss'], label= 'val')
plt.legend()
plt.show()

model_ns.evaluate(X3_test_full, y3_test, verbose=1)

10/10 ━━━━━━━━━━━━━━━━━━━━ 0s 8ms/step - loss: 2.0410 - mae: 2.0410

[1.9857805967330933, 1.9857805967330933]

def baseline_model():
    model = Sequential()
    model.add(Dense(24, input_dim=X3_train_full.shape[1], activation='tanh'))
    model.add(BatchNormalization())
    model.add(Dense(8, activation='relu'))
    model.add(Dense(8, activation='relu'))
    model.add(Dense(1, input_dim=20, activation='linear'))
    
    #sgd = SGD(learning_rate=0.01, momentum=0.9, nesterov=True)
    #model.compile(loss='mean_squared_error', optimizer=sgd)
    model.compile(loss='mean_absolute_error',
                optimizer=tf.keras.optimizers.Adam(0.001))
    return model

# тренируем сеть
dnn_model = baseline_model()
dnn_model.summary()

Model: "sequential_17"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ dense_69 (Dense)                     │ (None, 24)                  │             312 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_17               │ (None, 24)                  │              96 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_70 (Dense)                     │ (None, 8)                   │             200 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_71 (Dense)                     │ (None, 8)                   │              72 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_72 (Dense)                     │ (None, 1)                   │               9 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 689 (2.69 KB)

 Trainable params: 641 (2.50 KB)

 Non-trainable params: 48 (192.00 B)

%%time
history = dnn_model.fit(
    X3_train_full,
    y3_train,
    validation_split=0.2,
    verbose=0, epochs=25)

CPU times: total: 11.4 s
Wall time: 12.5 s

hist = pd.DataFrame(history.history)
hist['epoch'] = history.epoch
hist.tail()

def plot_loss(history):
  plt.plot(history.history['loss'], label='Ошибка обучения')
  plt.plot(history.history['val_loss'], label='Ошибка валидации')
  plt.ylim([0, 3])
  plt.xlabel('Эпохи обучения')
  plt.ylabel('Ошибка прогноза')
  plt.legend()
  plt.grid(True)

plot_loss(history)

# Зададим функцию для визуализации факт/прогноз для результатов моделей
# Посмотрим на график результата работы модели
def actual_and_predicted_plot(orig, predict, var, model_name):
    plt.figure(figsize=(10,5))
    plt.title(f'Тестовые и прогнозные значения: {model_name}')
    plt.plot(orig, label = 'Тест')
    plt.plot(predict, label = 'Прогноз')
    plt.legend(loc = 'best')
    plt.ylabel(var)
    plt.xlabel('Количество наблюдений')
    plt.show()
actual_and_predicted_plot(y3_test.values, model_ns.predict(X3_test_full.values), 'Cоотношение матрица/наполнитель', 'Keras')

10/10 ━━━━━━━━━━━━━━━━━━━━ 0s 21ms/step

import pickle

# Сохранить модель в файл pickle  
model_pkl_file = "mybauman_kompozit_model.pkl"  
with open(model_pkl_file, 'wb') as file:  
 pickle.dump(model6, file)

	Соотношение матрица-наполнитель	Плотность, кг/м3	модуль упругости, ГПа	Количество отвердителя, м.%	Содержание эпоксидных групп,%_2	Температура вспышки, С_2	Поверхностная плотность, г/м2	Модуль упругости при растяжении, ГПа	Прочность при растяжении, МПа	Потребление смолы, г/м2	Угол нашивки, град	Шаг нашивки	Плотность нашивки
0	1.857143	2030.000000	738.736842	30.000000	22.267857	100.000000	210.000000	70.000000	3000.000000	220.000000	0	4.000000	57.000000
1	1.857143	2030.000000	738.736842	50.000000	23.750000	284.615385	210.000000	70.000000	3000.000000	220.000000	0	4.000000	60.000000
2	1.857143	2030.000000	738.736842	49.900000	33.000000	284.615385	210.000000	70.000000	3000.000000	220.000000	0	4.000000	70.000000
3	1.857143	2030.000000	738.736842	129.000000	21.250000	300.000000	210.000000	70.000000	3000.000000	220.000000	0	5.000000	47.000000
4	2.771331	2030.000000	753.000000	111.860000	22.267857	284.615385	210.000000	70.000000	3000.000000	220.000000	0	5.000000	57.000000
...	...	...	...	...	...	...	...	...	...	...	...	...	...
1018	2.271346	1952.087902	912.855545	86.992183	20.123249	324.774576	209.198700	73.090961	2387.292495	125.007669	90	9.076380	47.019770
1019	3.444022	2050.089171	444.732634	145.981978	19.599769	254.215401	350.660830	72.920827	2360.392784	117.730099	90	10.565614	53.750790
1020	3.280604	1972.372865	416.836524	110.533477	23.957502	248.423047	740.142791	74.734344	2662.906040	236.606764	90	4.161154	67.629684
1021	3.705351	2066.799773	741.475517	141.397963	19.246945	275.779840	641.468152	74.042708	2071.715856	197.126067	90	6.313201	58.261074
1022	3.808020	1890.413468	417.316232	129.183416	27.474763	300.952708	758.747882	74.309704	2856.328932	194.754342	90	6.078902	77.434468

	Соотношение матрица-наполнитель	Плотность, кг/м3	модуль упругости, ГПа	Количество отвердителя, м.%	Содержание эпоксидных групп,%_2	Температура вспышки, С_2	Поверхностная плотность, г/м2	Модуль упругости при растяжении, ГПа	Прочность при растяжении, МПа	Потребление смолы, г/м2	Угол нашивки, град	Шаг нашивки	Плотность нашивки
count	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000	1023.000000
mean	2.930366	1975.734888	739.923233	110.570769	22.244390	285.882151	482.731833	73.328571	2466.922843	218.423144	44.252199	6.899222	57.153929
std	0.913222	73.729231	330.231581	28.295911	2.406301	40.943260	281.314690	3.118983	485.628006	59.735931	45.015793	2.563467	12.350969
min	0.389403	1731.764635	2.436909	17.740275	14.254985	100.000000	0.603740	64.054061	1036.856605	33.803026	0.000000	0.000000	0.000000
25%	2.317887	1924.155467	500.047452	92.443497	20.608034	259.066528	266.816645	71.245018	2135.850448	179.627520	0.000000	5.080033	49.799212
50%	2.906878	1977.621657	739.664328	110.564840	22.230744	285.896812	451.864365	73.268805	2459.524526	219.198882	0.000000	6.916144	57.341920
75%	3.552660	2021.374375	961.812526	129.730366	23.961934	313.002106	693.225017	75.356612	2767.193119	257.481724	90.000000	8.586293	64.944961
max	5.591742	2207.773481	1911.536477	198.953207	33.000000	413.273418	1399.542362	82.682051	3848.436732	414.590628	90.000000	14.440522	103.988901

	Соотношение матрица-наполнитель	Плотность, кг/м3	модуль упругости, ГПа	Количество отвердителя, м.%	Содержание эпоксидных групп,%_2	Температура вспышки, С_2	Поверхностная плотность, г/м2	Модуль упругости при растяжении, ГПа	Прочность при растяжении, МПа	Потребление смолы, г/м2	Угол нашивки, град	Шаг нашивки	Плотность нашивки
Соотношение матрица-наполнитель	1.000000	0.003841	0.031700	-0.006445	0.019766	-0.004776	-0.006272	-0.008411	0.024148	0.072531	-0.031073	0.036437	-0.004652
Плотность, кг/м3	0.003841	1.000000	-0.009647	-0.035911	-0.008278	-0.020695	0.044930	-0.017602	-0.069981	-0.015937	-0.068474	-0.061015	0.080304
модуль упругости, ГПа	0.031700	-0.009647	1.000000	0.024049	-0.006804	0.031174	-0.005306	0.023267	0.041868	0.001840	-0.025417	-0.009875	0.056346
Количество отвердителя, м.%	-0.006445	-0.035911	0.024049	1.000000	-0.000684	0.095193	0.055198	-0.065929	-0.075375	0.007446	0.038570	0.014887	0.017248
Содержание эпоксидных групп,%_2	0.019766	-0.008278	-0.006804	-0.000684	1.000000	-0.009769	-0.012940	0.056828	-0.023899	0.015165	0.008052	0.003022	-0.039073
Температура вспышки, С_2	-0.004776	-0.020695	0.031174	0.095193	-0.009769	1.000000	0.020121	0.028414	-0.031763	0.059954	0.020695	0.025795	0.011391
Поверхностная плотность, г/м2	-0.006272	0.044930	-0.005306	0.055198	-0.012940	0.020121	1.000000	0.036702	-0.003210	0.015692	0.052299	0.038332	-0.049923
Модуль упругости при растяжении, ГПа	-0.008411	-0.017602	0.023267	-0.065929	0.056828	0.028414	0.036702	1.000000	-0.009009	0.050938	0.023003	-0.029468	0.006476
Прочность при растяжении, МПа	0.024148	-0.069981	0.041868	-0.075375	-0.023899	-0.031763	-0.003210	-0.009009	1.000000	0.028602	0.023398	-0.059547	0.019604
Потребление смолы, г/м2	0.072531	-0.015937	0.001840	0.007446	0.015165	0.059954	0.015692	0.050938	0.028602	1.000000	-0.015334	0.013394	0.012239
Угол нашивки, град	-0.031073	-0.068474	-0.025417	0.038570	0.008052	0.020695	0.052299	0.023003	0.023398	-0.015334	1.000000	0.023616	0.107947
Шаг нашивки	0.036437	-0.061015	-0.009875	0.014887	0.003022	0.025795	0.038332	-0.029468	-0.059547	0.013394	0.023616	1.000000	0.003487
Плотность нашивки	-0.004652	0.080304	0.056346	0.017248	-0.039073	0.011391	-0.049923	0.006476	0.019604	0.012239	0.107947	0.003487	1.000000

	Соотношение матрица-наполнитель	Плотность, кг/м3	модуль упругости, ГПа	Количество отвердителя, м.%	Содержание эпоксидных групп,%_2	Температура вспышки, С_2	Поверхностная плотность, г/м2	Потребление смолы, г/м2	Шаг нашивки	Плотность нашивки
105	0.596032	0.494439	0.762209	0.391615	0.671034	0.715201	0.058942	0.638334	0.254871	0.798548
68	0.413173	0.355647	0.692996	0.807889	0.530145	0.565001	0.692435	0.262751	0.313013	0.590592
479	0.215916	0.513525	0.550207	0.143101	0.444434	0.848457	0.220757	0.532361	0.418369	0.831190
399	0.719356	0.495919	0.513662	0.511483	0.434786	0.777624	0.306908	0.849586	0.752301	0.778733
434	0.598195	0.618656	0.451483	0.489548	0.541908	0.381750	0.641074	0.475610	0.520836	0.437553

	Actual	Predicted
1016	3.745862	2.809768
881	4.864317	2.556128
308	2.187945	3.049427

	Unnamed: 0	Соотношение матрица-наполнитель	Плотность, кг/м3	модуль упругости, ГПа	Количество отвердителя, м.%	Содержание эпоксидных групп,%_2	Температура вспышки, С_2	Поверхностная плотность, г/м2	Модуль упругости при растяжении, ГПа	Прочность при растяжении, МПа	Потребление смолы, г/м2
0	0	1.857143	2030.0	738.736842	30.00	22.267857	100.000000	210.0	70.0	3000.0	220.0
1	1	1.857143	2030.0	738.736842	50.00	23.750000	284.615385	210.0	70.0	3000.0	220.0
2	2	1.857143	2030.0	738.736842	49.90	33.000000	284.615385	210.0	70.0	3000.0	220.0
3	3	1.857143	2030.0	738.736842	129.00	21.250000	300.000000	210.0	70.0	3000.0	220.0
4	4	2.771331	2030.0	753.000000	111.86	22.267857	284.615385	210.0	70.0	3000.0	220.0

	Соотношение матрица-наполнитель	Плотность, кг/м3	модуль упругости, ГПа	Количество отвердителя, м.%	Содержание эпоксидных групп,%_2	Температура вспышки, С_2	Поверхностная плотность, г/м2	Потребление смолы, г/м2	Шаг нашивки	Плотность нашивки
0	0.282131	0.601381	0.447061	0.123047	0.607435	0.482823	0.16223	0.517418	0.275109	0.544652
1	0.282131	0.601381	0.447061	0.608021	0.418887	0.549664	0.16223	0.517418	0.344539	0.365074
2	0.457857	0.601381	0.455721	0.502800	0.495653	0.482823	0.16223	0.517418	0.344539	0.503211
3	0.457201	0.527898	0.452685	0.502800	0.495653	0.482823	0.16223	0.517418	0.344539	0.544652
4	0.419084	0.307448	0.488508	0.502800	0.495653	0.482823	0.16223	0.517418	0.344539	0.682789

	estimator	RandomForestR...ndom_state=33)
	param_grid	{'criterion': ['absolute_error'], 'max_depth': [9, 15], 'max_features': ['sqrt'], 'n_estimators': [200, 300]}
	scoring	None
	n_jobs	None
	refit	True
	cv	10
	verbose	0
	pre_dispatch	'2*n_jobs'
	error_score	nan
	return_train_score	False

	n_estimators	200
	criterion	'absolute_error'
	max_depth	9
	min_samples_split	2
	min_samples_leaf	1
	min_weight_fraction_leaf	0.0
	max_features	'sqrt'
	max_leaf_nodes	None
	min_impurity_decrease	0.0
	bootstrap	True
	oob_score	False
	n_jobs	None
	random_state	33
	verbose	0
	warm_start	False
	ccp_alpha	0.0
	max_samples	None
	monotonic_cst	None

	Регрессор	MAE
0	RandomForest	2.578553
1	Linear Regression	2.510989
2	KNeighbors	2.803555
3	Support Vector	3.124316
4	GradientBoosting	2.597720
5	DecisionTree	3.551074

	loss	'squared_error'
	hidden_layer_sizes	30
	activation	'relu'
	solver	'adam'
	alpha	0.0001
	batch_size	'auto'
	learning_rate	'constant'
	learning_rate_init	0.001
	power_t	0.5
	max_iter	4000
	shuffle	True
	random_state	None
	tol	0.0001
	verbose	True
	warm_start	False
	momentum	0.9
	nesterovs_momentum	True
	early_stopping	True
	validation_fraction	0.2
	beta_1	0.9
	beta_2	0.999
	epsilon	1e-08
	n_iter_no_change	10
	max_fun	15000

	loss	val_loss	epoch
20	0.744686	0.871216	20
21	0.751577	0.855331	21
22	0.735922	0.835122	22
23	0.718570	0.828618	23
24	0.740217	0.826714	24

	Unnamed: 0	Шаг нашивки	Плотность нашивки
0	0	4.0	57.0
1	1	4.0	60.0
2	2	4.0	70.0
3	3	5.0	47.0
4	4	5.0	57.0

	Шаг нашивки	Плотность нашивки
0	4.0	57.0
1	4.0	60.0
2	4.0	70.0
3	5.0	47.0
4	5.0	57.0